The InteractiveImage command provided with datashader makes it simple to make an interactive plot of a very large dataset, but very often one will want to add additional interactive controls to filter your data, select columns for plotting, etc., which is not supported by InteractiveImage. One way to do that is to use ParamNB to instantiate some parameters and then have it run the subsequent cell whenever one of those parameters changes (via paramnb.Widgets(...,next_n=1) ).

This notebook illustrates a cleaner way using a HoloViews stream to connect the widgets and the plot. Requires conda install -c ioam/label/dev holoviews paramnb and installing GeoViews (which is only important for the map tile support).

Setup ¶

Interactive plot ¶

If you are viewing a static copy of this page through Anaconda Cloud, the interactive controls will not be usable, but you can download a copy of this notebook and run it through Jupyter notebook for the interactive version. You can also view the controls and the image as a deployable dashboard using Jupyter Dashboards , which can be installed separately using conda install -c conda-forge jupyter_dashboards . Jupyter Dashboards is a Jupyter extension that lets you choose which cells to publish to a dashboard layout, with the result like this screenshot that can be deployed as a standalone server.

How does it work? ¶

In this example, we define a class that declares certain parameters whose value a user might wish to change, with defaults, ranges, and documentation if desired. We then add a method make_view that constructs a HoloViews object using the values of these parameters, and we instantiate our new class as an object:

Here we could change the values of the parameters manually if we wanted:

But we'd rather have some interactive controls, so let's make some ipywidgets for the parameters, using ParamNB:

Now we have widgets that change the corresponding parameters on selector2 . Plus, whenever those values change, Widgets will call selector2.update() . But at this point, that method call does nothing, because we haven't registered anything with selector2 to watch for such events.

So, now we need to make something that could register for such events and generate the corresponding plot. Just getting a plot is simple, using the method we defined already:

This makes a HoloViews "view" object, which is then automatically turned into a Bokeh plot in a Jupyter notebook. But this plot won't dynamically update when the widgets are adjusted; it just respects whatever parameter values selector2 had when make_view() was invoked. To make the connection between the HoloViews object and the parameter widgets, we need one last line:

hv.DynamicMap(selector2.make_view, kdims=[], streams=[selector, RangeXY()])

Here, a DynamicMap is a HoloViews wrapper that accepts a callback ( selector2.make_view in this case) that it will call when a new HoloViews object is needed. Finally, the streams argument subscribes this DynamicMap to two streams, requesting that those streams trigger an update on the DynamicMap when the widget values change (via the selector stream) and when the Bokeh zoom range changes (via the RangeXY() stream). In either case, the DynamicMap will then execute the provided command to generate a new view, and ultimately the plot on your screen will update. Success!

[The kdims argument is unused here, because all of the dynamism here is provided by widgets and range changes, but in general we could also declare some "key dimensions" (e.g. "date"), and then there would be additional sliders created automatically to select values along those dimensions, which would then also trigger a call to selector2.make_view .]

While the approach outlined here is more complicated than having a single callback (which is of course also supported directly by paramnb), what it achieves is to be able to very flexibly create and subscribe to a wide variety of different event streams, each individually very simple and straightforward to create but which can be combined in arbitrary ways to create complex interactive behavior. See the new HoloViews Streams tutorials for more information, which explains how to watch for selection events, click events, keypress events, etc., all of which can be used to provide interactive behavior for Bokeh plots beyond what paramnb's widgets support.